9. 测试

grails create-controller simple

grails test-app

-------------------------------------------------------
Running Unit Tests…
Running test FooTests...FAILURE
Unit Tests Completed in 464ms …
-------------------------------------------------------
Tests failed: 0 errors, 1 failures

grails test-app SimpleController

grails test-app SimpleController BookController

class MyService {
    def otherService
      String createSomething() { 
                def stringId = otherService.newIdentifier()
                def item = new Item(code: stringId, name: "Bangle") 
                item.save() 
                return stringId 
        }
    int countItems(String name) { 
                def items = Item.findAllByName(name) 
                return items.size() 
        } 
}

import grails.test.GrailsUnitTestCase
class MyServiceTests extends GrailsUnitTestCase { 
        void testCreateSomething() { 
                // Mock the domain class. 
                def testInstances = [] 
                mockDomain(Item, testInstances)
           // Mock the "other" service. 
                String testId = "NH-12347686" 
                def otherControl = mockFor(OtherService) 
                otherControl.demand.newIdentifier(1..1) {-> return testId }
               //      Initialise the service and test the target method. 
                def testService = new MyService() 
                testService.otherService = otherControl.createMock()
              def retval = testService.createSomething()
                // Check that the method returns the identifier returned by the 
                // mock "other" service and also that a new Item instance has 
                // been saved. 
                assertEquals testId, retval 
                assertEquals 1, testInstances 
                assertTrue testInstances[0] instanceof Item 
        }
    void testCountItems() { 
                // Mock the domain class, this time providing a list of test 
                // Item instances that can be searched. 
                def testInstances = [ new Item(code: "NH-4273997", name: "Laptop"), 
                                                          new Item(code: "EC-4395734", name: "Lamp"), 
                                                          new Item(code: "TF-4927324", name: "Laptop") ] 
                mockDomain(Item, testInstances)
           // Initialise the service and test the target method. def testService = new MyService()
             assertEquals 2, testService.countItems("Laptop") 
                assertEquals 1, testService.countItems("Lamp") 
                assertEquals 0, testService.countItems("Chair") 
        } 
}

def testInstances = [] 
mockDomain(Item, testInstances)

def otherControl = mockFor(OtherService) 
otherControl.demand.newIdentifier(1..1) {-> return testId }

def testInstances = [ new Item(code: "NH-4273997", name: "Laptop"), 
                                          new Item(code: "EC-4395734", name: "Lamp"), 
                                          new Item(code: "TF-4927324", name: "Laptop") ] 
mockDomain(Item, testInstances)

mockFor(class, loose = false)

def strictControl = mockFor(MyService)
strictControl.demand.someMethod(0..2) { String arg1, int arg2 -> … }
strictControl.demand.static.aStaticMethod {-> … }

def looseControl = mockFor(MyService, true)

class Book {
    String title
    String author
    static constraints = { 
                title(blank: false, unique: true) 
                author(blank: false, minSize: 5) 
        } 
}

class BookTests extends GrailsUnitTestCase {
    void testConstraints() {
        def existingBook = new Book(title: "Misery", author: "Stephen King")
        mockForConstraintsTests(Book, [ existingBook ])
           // Validation should fail if both properties are null. 
                def book = new Book() 
                assertFalse book.validate() 
                assertEquals "nullable", book.errors["title"] 
                assertEquals "nullable", book.errors["author"]
            // So let's demonstrate the unique and minSize constraints. 
                book = new Book(title: "Misery", author: "JK") 
                assertFalse book.validate() 
                assertEquals "unique",      book.errors["title"] 
                assertEquals "minSize", book.errors["author"]
             // Validation should pass! 
                book = new Book(title: "The Shining", author: "Stephen King") 
                assertTrue book.validate() 
        } 
}

class FooController {
        def text = {
            render "bar"
        }
    def someRedirect = {
                redirect(action:"bar")
        }
}

class FooControllerTests extends GroovyTestCase {
  void testText() {
                def fc = new FooController()
                fc.text()
                assertEquals "bar", fc.response.contentAsString
        }
    void testSomeRedirect() {
            def fc = new FooController()
                fc.someRedirect()
                assertEquals "/foo/bar", fc.response.redirectedUrl
        }
}

class FilmStarsController {
    def popularityService
    def update = {
        // do something with popularityService
    }
}

class FilmStarsTests extends GroovyTestCase {
    def popularityService
    public void testInjectedServiceInController () {
        def fsc = new FilmStarsController()
        fsc.popularityService = popularityService
        fsc.update()
    }
}

class AuthenticationController {
    def signup = { SignupForm form ->
        …
    }
}

def controller = new AuthenticationController()
controller.params.login = "marcpalmer"
controller.params.password = "secret"
controller.params.passwordConfirm = "secret"
controller.signup()

def save = {
        def book = Book(params)
        if(book.save()) {
                // handle
        }
        else {
                render(view:"create", model:[book:book])
        }
}

def bookController = new BookController()
bookController.save()
def model = bookController.modelAndView.model.book

def create = {
        [book: new Book(params['book']) ] 
}

void testCreateWithXML() {
        def controller = new BookController()
        controller.request.contentType = 'text/xml'
        controller.request.contents = '''<?xml version="1.0" encoding="ISO-8859-1"?>
        <book>
                <title>The Stand</title>
                …
        </book> 
        '''.getBytes() // note we need the bytes
  def model = controller.create()
        assert model.book
        assertEquals "The Stand", model.book.title
}

void testCreateWithJSON() {
        def controller = new BookController()     
        controller.request.contentType = "text/json"
        controller.request.content = '{"id":1,"class":"Book","title":"The Stand"}'.getBytes()
       def model = controller.create()
        assert model.book
        assertEquals "The Stand", model.book.title
}

class ExampleController {
        def exampleFlow = {
                start {
                        on("go") {
                                flow.hello = "world"
                        }.to "next"
                }
                next {
                        on("back").to "start"
                        on("go").to "end"
                }
                end()
        }  
}

class ExampleFlowTests extends grails.test.WebFlowTestCase {
        def getFlow() { new ExampleController().exampleFlow }
        …
}

class ExampleFlowTests extends grails.test.WebFlowTestCase {
        String getFlowId() { "example" }
        …
}

void testExampleFlow() {
        def viewSelection = startFlow()
   assertEquals "start", viewSelection.viewName
        …
}

void testExampleFlow() {
        …
        viewSelection = signalEvent("go")
        assertEquals "next", viewSelection.viewName
        assertEquals "world", viewSelection.model.hello
}

class FooTagLib {
   def bar =  { attrs, body ->
           out << "<p>Hello World!</p>"
   }
   def bodyTag =  { attrs, body ->
      out << "<${attrs.name}>"
           out << body()
      out << "</${attrs.name}>"           
   }
}

class FooTagLibTests extends GroovyTestCase {
  void testBarTag() {
           assertEquals "<p>Hello World!</p>", new FooTagLib().bar(null,null)
   }
   void testBodyTag() {
           assertEquals "<p>Hello World!</p>", new FooTagLib().bodyTag(name:"p") {
               "Hello World!" 
       }
    }
}

class FormatTagLib {
        def dateFormat = { attrs, body -> 
                out << new java.text.SimpleDateFormat(attrs.format) << attrs.date
        }
}

class FormatTagLibTests extends GroovyPagesTestCase {
        void testDateFormat() {
                def template = '<g:dateFormat format="dd-MM-yyyy" date="${myDate}" />'
          def testDate = … // create the date
                assertOutputEquals( '01-01-2008', template, [myDate:testDate] )
        }
}

class FormatTagLibTests extends GroovyPagesTestCase {
        void testDateFormat() {
                def template = '<g:dateFormat format="dd-MM-yyyy" date="${myDate}" />'
          def testDate = … // create the date
                def result = applyTemplate( template, [myDate:testDate] )
         assertEquals '01-01-2008', result
        }
}

void testQuery() {
        def books = [ new Book(title:"The Stand"), new Book(title:"The Shining")]
        books*.save()
 assertEquals 2, Book.list().size()
}

void testQuery() {
        def books = [ new Book(title:"The Stand"), new Book(title:"The Shining")]
        books*.save(flush:true)
 assertEquals 2, Book.list().size()
}

grails install-plugin webtest